using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("MulliganManager")]
	public class MulliganManager : MonoBehaviour
	{
		public GameObject coinPrefab => method_3<GameObject>("coinPrefab");

		public GameObject weldPrefab => method_3<GameObject>("weldPrefab");

		public GameObject mulliganChooseBannerPrefab => method_3<GameObject>("mulliganChooseBannerPrefab");

		public GameObject mulliganKeepLabelPrefab => method_3<GameObject>("mulliganKeepLabelPrefab");

		public MulliganReplaceLabel mulliganReplaceLabelPrefab => method_3<MulliganReplaceLabel>("mulliganReplaceLabelPrefab");

		public GameObject mulliganXlabelPrefab => method_3<GameObject>("mulliganXlabelPrefab");

		public GameObject mulliganTimerPrefab => method_3<GameObject>("mulliganTimerPrefab");

		public GameObject heroLabelPrefab => method_3<GameObject>("heroLabelPrefab");

		public static float PHONE_HEIGHT_OFFSET => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MulliganManager", "PHONE_HEIGHT_OFFSET");

		public static float PHONE_CARD_Z_OFFSET => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MulliganManager", "PHONE_CARD_Z_OFFSET");

		public static float PHONE_CARD_SCALE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MulliganManager", "PHONE_CARD_SCALE");

		public static float PHONE_ZONE_SIZE_ADJUST => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MulliganManager", "PHONE_ZONE_SIZE_ADJUST");

		public bool mulliganActive => method_2<bool>("mulliganActive");

		public MulliganTimer m_mulliganTimer => method_3<MulliganTimer>("m_mulliganTimer");

		public NormalButton mulliganButton => method_3<NormalButton>("mulliganButton");

		public GameObject myWeldEffect => method_3<GameObject>("myWeldEffect");

		public GameObject hisWeldEffect => method_3<GameObject>("hisWeldEffect");

		public GameObject coinObject => method_3<GameObject>("coinObject");

		public GameObject startingHandZone => method_3<GameObject>("startingHandZone");

		public GameObject coinTossText => method_3<GameObject>("coinTossText");

		public ZoneHand friendlySideHandZone => method_3<ZoneHand>("friendlySideHandZone");

		public ZoneHand opposingSideHandZone => method_3<ZoneHand>("opposingSideHandZone");

		public ZoneDeck friendlySideDeck => method_3<ZoneDeck>("friendlySideDeck");

		public ZoneDeck opposingSideDeck => method_3<ZoneDeck>("opposingSideDeck");

		public Actor myHeroCardActor => method_3<Actor>("myHeroCardActor");

		public Actor hisHeroCardActor => method_3<Actor>("hisHeroCardActor");

		public Actor myHeroPowerCardActor => method_3<Actor>("myHeroPowerCardActor");

		public Actor hisHeroPowerCardActor => method_3<Actor>("hisHeroPowerCardActor");

		public bool waitingForVersusText => method_2<bool>("waitingForVersusText");

		public GameStartVsLetters versusText => method_3<GameStartVsLetters>("versusText");

		public bool waitingForVersusVo => method_2<bool>("waitingForVersusVo");

		public bool introComplete => method_2<bool>("introComplete");

		public bool skipCardChoosing => method_2<bool>("skipCardChoosing");

		public List<Card> m_startingCards => method_3<Class271<Card>>("m_startingCards")?.method_25();

		public List<Card> m_startingOppCards => method_3<Class271<Card>>("m_startingOppCards")?.method_25();

		public int m_coinCardIndex => method_2<int>("m_coinCardIndex");

		public int m_bonusCardIndex => method_2<int>("m_bonusCardIndex");

		public GameObject mulliganChooseBanner => method_3<GameObject>("mulliganChooseBanner");

		public List<MulliganReplaceLabel> m_replaceLabels => method_3<Class271<MulliganReplaceLabel>>("m_replaceLabels")?.method_25();

		public List<GameObject> m_xLabels => method_3<Class251<GameObject>>("m_xLabels")?.method_25();

		public List<bool> m_handCardsMarkedForReplace => method_3<Class250<bool>>("m_handCardsMarkedForReplace")?.method_25();

		public Vector3 coinLocation => method_2<Vector3>("coinLocation");

		public bool friendlyPlayerGoesFirst => method_2<bool>("friendlyPlayerGoesFirst");

		public HeroLabel myheroLabel => method_3<HeroLabel>("myheroLabel");

		public HeroLabel hisheroLabel => method_3<HeroLabel>("hisheroLabel");

		public Spell m_MyCustomSocketInSpell => method_3<Spell>("m_MyCustomSocketInSpell");

		public Spell m_HisCustomSocketInSpell => method_3<Spell>("m_HisCustomSocketInSpell");

		public bool m_isLoadingMyCustomSocketIn => method_2<bool>("m_isLoadingMyCustomSocketIn");

		public bool m_isLoadingHisCustomSocketIn => method_2<bool>("m_isLoadingHisCustomSocketIn");

		public static float ANIMATION_TIME_DEAL_CARD => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MulliganManager", "ANIMATION_TIME_DEAL_CARD");

		public static float DEFAULT_STARTING_TAUNT_DURATION => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MulliganManager", "DEFAULT_STARTING_TAUNT_DURATION");

		public bool friendlyPlayerHasReplacementCards => method_2<bool>("friendlyPlayerHasReplacementCards");

		public bool opponentPlayerHasReplacementCards => method_2<bool>("opponentPlayerHasReplacementCards");

		public bool m_waitingForUserInput => method_2<bool>("m_waitingForUserInput");

		public Notification innkeeperMulliganDialog => method_3<Notification>("innkeeperMulliganDialog");

		public bool m_resuming => method_2<bool>("m_resuming");

		public MulliganManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public MulliganManager(IntPtr address)
			: this(address, "MulliganManager")
		{
		}

		public static MulliganManager Get()
		{
			return MonoClass.smethod_15<MulliganManager>(TritonHs.MainAssemblyPath, "", "MulliganManager", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public bool IsMulliganActive()
		{
			return method_11<bool>("IsMulliganActive", Array.Empty<object>());
		}

		public void ForceMulliganActive(bool active)
		{
			method_8("ForceMulliganActive", active);
		}

		public void OnMulliganButtonLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnMulliganButtonLoaded", assetRef, go, callbackData);
		}

		public void OnVersusVoLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnVersusVoLoaded", assetRef, go, callbackData);
		}

		public void OnVersusTextLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnVersusTextLoaded", assetRef, go, callbackData);
		}

		public void BeginMulligan()
		{
			method_8("BeginMulligan");
		}

		public void OnCreateGame(GameState.CreateGamePhase phase, object userData)
		{
			method_8("OnCreateGame", phase, userData);
		}

		public void HandleGameStart()
		{
			method_8("HandleGameStart");
		}

		public void OnMulliganTimerUpdate(TurnTimerUpdate update, object userData)
		{
			method_8("OnMulliganTimerUpdate", update, userData);
		}

		public bool OnEntitiesChosenReceived(Network.EntitiesChosen chosen, object userData)
		{
			return method_11<bool>("OnEntitiesChosenReceived", new object[2] { chosen, userData });
		}

		public void OnGameOver(TAG_PLAYSTATE playState, object userData)
		{
			method_8("OnGameOver", playState, userData);
		}

		public void InitZones()
		{
			method_8("InitZones");
		}

		public bool ShouldWaitForMulliganCardsToBeProcessed()
		{
			return method_11<bool>("ShouldWaitForMulliganCardsToBeProcessed", Array.Empty<object>());
		}

		public bool IsTaskListPuttingUsPastMulligan(PowerTaskList taskList)
		{
			return method_11<bool>("IsTaskListPuttingUsPastMulligan", new object[1] { taskList });
		}

		public void GetStartingLists()
		{
			method_8("GetStartingLists");
		}

		public void BeginMulliganCountdown(float endTimeStamp)
		{
			method_8("BeginMulliganCountdown", endTimeStamp);
		}

		public NormalButton GetMulliganButton()
		{
			return method_14<NormalButton>("GetMulliganButton", Array.Empty<object>());
		}

		public void CoinTossTextCallback(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("CoinTossTextCallback", assetRef, go, callbackData);
		}

		public MulliganReplaceLabel CreateNewUILabelAtCardPosition(MulliganReplaceLabel prefab, int cardPosition)
		{
			return method_14<MulliganReplaceLabel>("CreateNewUILabelAtCardPosition", new object[2] { prefab, cardPosition });
		}

		public void SetAllMulliganCardsToHold()
		{
			method_8("SetAllMulliganCardsToHold");
		}

		public void ToggleHoldState(int startingCardsIndex)
		{
			method_9("ToggleHoldState", new Class276.Enum20[1] { Class276.Enum20.I4 }, startingCardsIndex);
		}

		public void DestroyXobjects()
		{
			method_8("DestroyXobjects");
		}

		public void DestroyChooseBanner()
		{
			method_8("DestroyChooseBanner");
		}

		public void DestroyMulliganTimer()
		{
			method_8("DestroyMulliganTimer");
		}

		public void ToggleHoldState(Card toggleCard)
		{
			method_9("ToggleHoldState", new Class276.Enum20[1] { Class276.Enum20.Class }, toggleCard);
		}

		public void ServerHasDealtReplacementCards(bool isFriendlySide)
		{
			method_8("ServerHasDealtReplacementCards", isFriendlySide);
		}

		public void AutomaticContinueMulligan()
		{
			method_8("AutomaticContinueMulligan");
		}

		public void OnMulliganButtonReleased(UIEvent e)
		{
			method_8("OnMulliganButtonReleased", e);
		}

		public void BeginDealNewCards()
		{
			method_8("BeginDealNewCards");
		}

		public void DestroyButton(object buttonToDestroy)
		{
			method_8("DestroyButton", buttonToDestroy);
		}

		public void HandleGameOverDuringMulligan()
		{
			method_8("HandleGameOverDuringMulligan");
		}

		public void EndMulligan()
		{
			method_8("EndMulligan");
		}

		public bool IsCoinCard(Card card)
		{
			return method_11<bool>("IsCoinCard", new object[1] { card });
		}

		public Card GetCoinCardFromFriendlyHand()
		{
			return method_14<Card>("GetCoinCardFromFriendlyHand", Array.Empty<object>());
		}

		public void PutCoinCardInSpawnPosition(Card coinCard)
		{
			method_8("PutCoinCardInSpawnPosition", coinCard);
		}

		public bool ShouldHandleCoinCard()
		{
			return method_11<bool>("ShouldHandleCoinCard", Array.Empty<object>());
		}

		public void CoinCardSummonFinishedCallback(Spell spell, object userData)
		{
			method_8("CoinCardSummonFinishedCallback", spell, userData);
		}

		public void SkipCardChoosing()
		{
			method_8("SkipCardChoosing");
		}

		public void SkipMulliganForDev()
		{
			method_8("SkipMulliganForDev");
		}

		public void SkipMulligan()
		{
			method_8("SkipMulligan");
		}

		public void FadeOutMulliganMusicAndStartGameplayMusic()
		{
			method_8("FadeOutMulliganMusicAndStartGameplayMusic");
		}

		public void ShuffleDeck()
		{
			method_8("ShuffleDeck");
		}

		public void SlideCard(GameObject topCard)
		{
			method_8("SlideCard", topCard);
		}

		public void SortHand(Zone zone)
		{
			method_8("SortHand", zone);
		}

		public void FadeHeroPowerIn(Card heroPowerCard)
		{
			method_8("FadeHeroPowerIn", heroPowerCard);
		}

		public void LoadMyHeroSkinSocketInEffect(CardDef cardDef)
		{
			method_8("LoadMyHeroSkinSocketInEffect", cardDef);
		}

		public void OnMyHeroSkinSocketInEffectLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnMyHeroSkinSocketInEffectLoaded", assetRef, go, callbackData);
		}

		public void LoadHisHeroSkinSocketInEffect(CardDef cardDef)
		{
			method_8("LoadHisHeroSkinSocketInEffect", cardDef);
		}

		public void OnHisHeroSkinSocketInEffectLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnHisHeroSkinSocketInEffectLoaded", assetRef, go, callbackData);
		}

		public void DestoryHeroSkinSocketInEffects()
		{
			method_8("DestoryHeroSkinSocketInEffects");
		}
	}
}
